{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1\n",
    "java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2\n",
    "package 的作用就是 c++ 的 namespace 的作用，防止名字相同的类产生冲突。Java 编译器在编译时，直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。如 `package aaa.bbb.ccc` 编译器就将该 .java 文件下的各个类生成到 `./aaa/bbb/ccc/` 这个目录。\n",
    "\n",
    "import 是为了简化使用 package 之后的实例化的代码。假设 `./aaa/bbb/ccc/` 下的 A 类，假如没有 import，实例化A类为：`new aaa.bbb.ccc.A()`，使用 `import aaa.bbb.ccc.A` 后，就可以直接使用 `new A()` 了，也就是编译器匹配并扩展了 `aaa.bbb.ccc.` 这串字符串。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 \n",
    "**为什么JAVA文件中只能含有一个Public类?**\n",
    "\n",
    "java 程序是从一个 public 类的 main 函数开始执行的，(其实是main线程)，就像 C 程序 是从 main() 函数开始执行一样。 只能有一个 public 类是为了给类装载器提供方便。 一个 public 类只能定义在以它的类名为文件名的文件中。\n",
    "\n",
    "每个编译单元(文件)都只有一个 public 类。因为每个编译单元都只能有一个公共接口，用 public 类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的 public 类，编译器就会报错。 并且 public类的名称必须与文件名相同(严格区分大小写)。 当然一个编译单元内也可以没有 public 类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4\n",
    "**成员变量和类变量的区别**\n",
    "\n",
    "在java中，类变量（也叫静态变量）是类中独立于方法之外的变量，用static 修饰。（static表示“全局的”、“静态的”，用来修饰成员变量和成员方法，或静态代码块（静态代码块独立于类成员，jvm加载类时会执行静态代码块，每个代码块只执行一次，按顺序执行））。\n",
    "\n",
    "由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。\n",
    "\n",
    "不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。\n",
    "\n",
    "成员变量和类变量的区别：\n",
    "\n",
    "   1、两个变量的生命周期不同\n",
    "\n",
    "      成员变量随着对象的创建而存在，随着对象的回收而释放。\n",
    "\n",
    "      静态变量随着类的加载而存在，随着类的消失而消失。\n",
    "\n",
    "   2、调用方式不同\n",
    "\n",
    "      成员变量只能被对象调用。\n",
    "\n",
    "      静态变量可以被对象调用，还可以被类名调用。\n",
    "\n",
    "   3、别名不同\n",
    "\n",
    "      成员变量也称为实例变量。\n",
    "\n",
    "      静态变量也称为类变量。\n",
    "\n",
    "   4、数据存储位置不同\n",
    "\n",
    "      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。\n",
    "\n",
    "      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。\n",
    "\n",
    "static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。\n",
    "\n",
    "   特点：\n",
    "\n",
    "   1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。\n",
    "\n",
    "   2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。\n",
    "\n",
    "    3、静态随着类的加载而加载。而且优先于对象存在。\n",
    "\n",
    " \n",
    "\n",
    "弊端：\n",
    "\n",
    "   1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。\n",
    "\n",
    "   2、静态方法只能访问静态成员，不可以访问非静态成员。\n",
    "\n",
    "      因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。\n",
    "\n",
    "   3、静态方法中不能使用this，super关键字。\n",
    "\n",
    "      因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。\n",
    "\n",
    " \n",
    "\n",
    "什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？\n",
    "\n",
    "成员分两种：\n",
    "\n",
    "   1、成员变量。（数据共享时静态化）\n",
    "\n",
    "      该成员变量的数据是否是所有对象都一样：\n",
    "\n",
    "      如果是，那么该变量需要被静态修饰，因为是共享的数据。 \n",
    "\n",
    "      如果不是，那么就说这是对象的特有数据，要存储到对象中。 \n",
    "\n",
    "   2、成员函数。（方法中没有调用特有数据时就定义成静态）\n",
    "\n",
    "      如果判断成员函数是否需要被静态修饰呢？\n",
    "\n",
    "      只要参考，该函数内是否访问了对象中的特有数据：\n",
    "\n",
    "      如果有访问特有数据，那方法不能被静态修饰。\n",
    "\n",
    "      如果没有访问过特有数据，那么这个方法需要被静态修饰。\n",
    "\n",
    "成员变量和静态变量的区别：\n",
    "\n",
    "   1、成员变量所属于对象。所以也称为实例变量。\n",
    "\n",
    "      静态变量所属于类。所以也称为类变量。\n",
    "\n",
    "   2、成员变量存在于堆内存中。\n",
    "\n",
    "      静态变量存在于方法区中。\n",
    "\n",
    "   3、成员变量随着对象创建而存在。随着对象被回收而消失。\n",
    "\n",
    "      静态变量随着类的加载而存在。随着类的消失而消失。\n",
    "\n",
    "   4、成员变量只能被对象所调用 。\n",
    "\n",
    "      静态变量可以被对象调用，也可以被类名调用。\n",
    "\n",
    "   所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5\n",
    "**类的构造方法**\n",
    "\n",
    "1、构造方法的名字和类名相同，并且没有返回值。\n",
    "\n",
    "2、构造方法主要用于为类的对象定义初始化状态。\n",
    "\n",
    "3、我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。\n",
    "\n",
    "4、Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法。\n",
    "\n",
    "new关键字的作用\n",
    "\n",
    "1、为对象分配内存空间。\n",
    "\n",
    "2、引起对象构造方法的调用。\n",
    "\n",
    "3、为对象返回一个引用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6\n",
    "**成员变量和局部变量区别**\n",
    "\n",
    "1.声明位置不同\n",
    "\n",
    "成员变量也就是属性，在类中声明的。\n",
    "\n",
    "局部变量，在方法中声明或代码块中声明。\n",
    "\n",
    "2.初始值不同\n",
    "\n",
    "成员变量如果没有赋值则是有默认值的，数据类型不同则默认值不同。\n",
    "\n",
    "局部变量是没有默认值，也就是说必须先声明，再赋值，最后才使用。\n",
    "\n",
    "3.在一个类中，局部变量可以与成员变量同名，但是局部变量优先,如果非要访问成员变量的属性，则必须使用 this.color\n",
    "\n",
    "this 代表当前这个对象，也就是当前谁调用这个方法则这个对象就是谁。\n",
    "\n",
    "对象与引用区别\n",
    "对象是具体的一个实例，如：new Student(); new 表示创建一个对象，并在堆内存中开辟一块空间。\n",
    "\n",
    "引用名称是存放的对象的地址。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-28T05:27+0000",
     "start_time": "2020-10-28T05:27:16.008Z"
    }
   },
   "outputs": [],
   "source": [
    "public class Draw{\n",
    "    int a,b;    //a是要生成的菱形行数\n",
    "    int h;      //h是方法中的参数，也是行数\n",
    "    int i,j;    //i j是循环结构参数\n",
    "    public void draw(int h ){\n",
    "        for(i = 1 ;i <= h ;i++){         //逐行打印\n",
    "            for(j = 1;j <= h;j++){       //每行打印个数与行数保持一致\n",
    "                //下面语句是菱形四条边的函数，在边上的坐标点，打印*，否则打印空格\n",
    "                if(j == (h + 3) / 2 - i || j == (h - 1) / 2 + i || j == i - (h - 1 ) / 2 || j == (3 * h + 1) / 2 - i){\n",
    "                    System.out.print(\"*\");\n",
    "                }else{\n",
    "                    System.out.print(\" \");\n",
    "                }            \n",
    "            }    \n",
    "            System.out.println();        //第 i 行打印完换行\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-28T05:30+0000",
     "start_time": "2020-10-28T05:30:09.546Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *    \n",
      "   * *   \n",
      "  *   *  \n",
      " *     * \n",
      "*       *\n",
      " *     * \n",
      "  *   *  \n",
      "   * *   \n",
      "    *    \n"
     ]
    }
   ],
   "source": [
    "Draw b = new Draw();                  //初始化方法\n",
    "int h = 9;                          //赋值并执行draw方法\n",
    "b.draw(h);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "11.0.8+10-post-Ubuntu-0ubuntu120.04"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
